#!/usr/bin python
# -*- coding: latin-1 -*-
import ftplib, sys, os, stat
import socket
import time
import tarfile
from sqlobject.util.csvexport import export_csv
import subprocess
import shutil
import traceback
from logovani import gprsLogger
from nacteniKonfigurace import adresaProOvereniVPN, adresaProOvereniPPP 
from nacteniKonfigurace import razitkoGSMZije, semaforPrihlasenTechnik
from nacteniKonfigurace import pozadavekChciProvest
from nacteniKonfigurace import razitkoPrenosZahajenCentrala,semaforPrenesDataCentrala,pocetOpakovaniPrenosuCentrala
from nacteniKonfigurace import razitkoPrenosZahajenTelem,semaforPrenesDataTelem,pocetOpakovaniPrenosuTelem
from nacteniKonfigurace import pocetRadkuPredCritical, pocetRadkuPoCritical
#from nacteniKonfigurace import verzeFirmwarePIC
import commands, os, string
from tabulky import SmsProOdeslani
from sqlobject import *
from version import zjistiPythonSwVerzi
from podpurneFunkce import _zjistiCisloAutomatu

class GprsKomunikace(object):
    def __init__(self):        
        socket.setdefaulttimeout(60)
        self.chyba = ''
    
    def startGPRS(self):
        gprsLogger.info("********** pozadavek na spusteni GPRS **********") 
        for i in range(3):
            self.cisloPokusu = 1+i
            gprsLogger.info("pokus o nahozeni GPRS, jedna se o pokus cislo: %s" % self.cisloPokusu) 
            subprocess.call(["/usr/sbin/pppd call gprs"],shell=True)
            time.sleep(8) #dame mu chvili cas, aby se mohl spustit pppd a navazat GPRS spojeni
            if self.uspesnaKomunikaceGprs:                
                subprocess.call(["ntpdate -b -s ntp.tpc.cz"],shell=True) # seridime cas
                return True
            else:
                self.stopGPRS()
                time.sleep(1)
        gprsLogger.error("nahozeni GPRS neuspesne")
                
    def stopGPRS(self):
        text = "********** pozadavek na zastaveni GPRS **********"
        print text
        gprsLogger.info(text)
        vpnPID = self.existujePidOvereneBeziciVPN
        if vpnPID:
            subprocess.call(["kill %s" % vpnPID],shell=True)
        subprocess.call(["killall pppd"],shell=True)
        text = 'GPRS ukonceno'
        print text
        gprsLogger.info(text)
        time.sleep(1) # aby mel cas uvolnit seriovy port
        
        
    def startVPN(self):
        # nelze spoustet samostatne, nejdrive musi byt uspesne spusteno GPRS                
        gprsLogger.info("********** pozadavek na spusteni VPN **********") 
        for i in range(3):
            self.cisloPokusu = i+1
            if not self.pidBezicihoGPRS:
                self.startGPRS()            
            gprsLogger.info('pokus o nahozeni tpc vpn, jedna se o pokus c.: %s' % self.cisloPokusu)
            subprocess.call(["/usr/bin/nohup /usr/sbin/pppd call tpcvpn"],shell=True)
            if self.existujePidOvereneBeziciVPN:
                if self.uspesnaKomunikaceVpn:
                    return True
            else:
                self.stopGPRS()
                time.sleep(1)
        text = "nahozeni VPN neuspesne"
        gprsLogger.error(text)
        SmsProOdeslani(textZpravy = text)
        self.stopGPRS()
    
                    
    def overSpojeni(self, host):
        if host == adresaProOvereniPPP:
            typSpojeni = "GPRS"
        else:
            typSpojeni = "VPN"
        try:
            text = "OVERUJI FUNKCNOST SPOJENI %s DOTAZEM NA SERVER %s" % (typSpojeni,  host)
            gprsLogger.info(text)
            print text
            gprsLogger.info('pokus o pripravu ftp spojeni')
            conn = ftplib.FTP()
            gprsLogger.info('pokus o navazani spojeni se serverem')
            answer = conn.connect(host)
            conn.close()
            text = 'spojeni %s je nahozeno, odpoved serveru %s: %s' % (typSpojeni, host, answer)
            gprsLogger.info(text)
            print text
            return answer
        except Exception, why:
            if self.cisloPokusu != 3:
                gprsLogger.error('spojeni %s nenavazano' % typSpojeni)
                gprsLogger.error(why)
            else:
                gprsLogger.error('spojeni %s nenavazano' % typSpojeni)
                gprsLogger.error(why)                
    uspesnaKomunikaceGprs = property(fget = lambda self: self.overSpojeni(host=adresaProOvereniPPP))        
    uspesnaKomunikaceVpn  = property(fget = lambda self: self.overSpojeni(host=adresaProOvereniVPN))
    
    def _zVarRunOverPid(self, plnyNazevSouboru):        
        if os.path.exists(plnyNazevSouboru):
            f = open(plnyNazevSouboru, "r")
            nactenyRadek = f.readline() 
            f.close()
            PID = nactenyRadek.rstrip() # nacteme bez "\n"            
            if 'pppd' in commands.getoutput("ps -p %s" % PID):
#                text = "overeni PID bylo uspesne, %s obsahuje cislo aktualne beziciho procesu" % plnyNazevSouboru
#                print text
#                gprsLogger.info(text)
                return PID
            text = "%s neobsahuje cislo aktualne beziciho procesu" % plnyNazevSouboru
            print text
            gprsLogger.error(text)
    pidBezicihoGPRS =             property(fget = lambda self: self._zVarRunOverPid("/var/run/ppp0.pid"))
    existujePidOvereneBeziciVPN = property(fget = lambda self: self._zVarRunOverPid("/var/run/ppp1.pid"))

    
    
    def zalogujSeNaFtpServer(self, ftpHost,  ftpUser, ftpPassw, absCestaRootNaServeruFTP):
        '''
        pomoci knihovny ftplib se zalogujeme na ftp server        
        '''
        for i in range(3):
            try:
                self.ftp = ftplib.FTP(ftpHost)
                self.ftp.login(ftpUser, ftpPassw)
                self.changeWorkingDirectoryOnFtpServer(absCestaRootNaServeruFTP) 
                break
            except Exception, why:
                print Exception, why            
                self.chyba += 'nepodarilo se zalogovat na server ftp %s\n' % ftpHost
                self.chyba += str(why)
                gprsLogger.critical(self.chyba)
            time.sleep(5)
            gprsLogger.error('pokousim se o nove ftp pripojeni')
            
    def ukonciFTP(self):
        self.ftp.close()

    def opatrneNlst(self,remDir=None):
        '''
        Provede nlst s kontrolou vyjimky, wu-ftpd totiz vraci perm. chybu u prazdneho adresare.
        VSFTPD vraci prazdny seznam, windows ftp server taky.
        '''
        try:
            if not remDir: seznam=self.ftp.nlst()
            else: seznam=self.ftp.nlst(remDir)
        except ftplib.error_perm:
            seznam=[]
        return seznam
            
    def archivyDanehoAdresarePosliNaFtpServer(self, localDirectory, remoteDirectory):
        '''
        z lokalniho adresare localDirectory odesleme do remoteDirectory vsechny tar.bz2 soubory         
        '''
        self.changeWorkingDirectoryOnFtpServer(remoteDirectory)        
        os.chdir(localDirectory)
        for localFileName in os.listdir(localDirectory):
            fullPathLocalFileName = "%s%s" % (localDirectory , localFileName)
            if os.path.isfile(fullPathLocalFileName):
                #if tarfile.is_tarfile(fullPathLocalFileName):
                if localFileName.endswith(".tar.bz2"):
                    myFile = open(localFileName, "rb")# otevirame jako binary
                    self.ftp.storbinary("STOR " + localFileName, myFile, 1024)
                    myFile.close()
            
    def changeWorkingDirectoryOnFtpServer(self, remoteDirectory):
        '''
        zmeni working directory na ftp serveru, v pripade, ze zadany adresar neexistuje,
        pokusi se ho vytvorit        
        '''
        if remoteDirectory:
            try:
                self.ftp.cwd(remoteDirectory)
            except ftplib.error_perm:
                self.ftp.mkd(remoteDirectory)
                self.ftp.cwd(remoteDirectory)
            except AttributeError:
                chyba = traceback.format_exc()
                gprsLogger.critical(chyba)
#                self.ukonciFTP()
#                self.stopGPRS()
        

    def stahniZeServeruFtp(self, remoteDirectory, localTargetDirectory):
        '''
        ze zadaneho adresare na ftp serveru (remoteDirectory) stahneme vsechny soubory a ulozime
        jej do 'localTargetDirectory'
        '''        
        try:
            self.changeWorkingDirectoryOnFtpServer(remoteDirectory)
            seznamSouboru = self.opatrneNlst(remoteDirectory)
            for remoteFilePathAndName in seznamSouboru:                
                try:
                    remoteFileName = os.path.split(remoteFilePathAndName)[-1]                    
                    remoteFileNameExtension = os.path.splitext(remoteFileName)[-1] #z nazvu souboru ziskame jeho extenzi
                    localFilePathAndName = localTargetDirectory+remoteFileName                    
                    if remoteFileNameExtension in (".txt", ".htm", ".html", ".py", ".ini", ".csv", ".sh"):
                        myFile = open(localFilePathAndName, 'w')
                        self.ftp.retrlines('RETR %s' % remoteFileName, myFile.write)
                    else:
                        myFile = open(localFilePathAndName, 'wb')
                        self.ftp.retrbinary('RETR %s' % remoteFileName, myFile.write)
                except ftplib.error_perm: #kdyz to je adresar                    
                    continue
            return True                    
        except ftplib.all_errors,  why:            
            self.chyba += str(why)
            gprsLogger.critical(self.chyba)
            
    def naFtpServeruVymazSouborySeStejnymJmenem(self, remoteDirectory, localDirectory):
        '''
        prochazi vsechny soubory v localDirectory a pokousi se vymazat soubor se 
        stejnym jmenem na na ftp serveru         
        '''
        self.changeWorkingDirectoryOnFtpServer(remoteDirectory)
        seznamFullPathSouboruNaFtpServeru = self.opatrneNlst(remoteDirectory) # vrati list plnych cest souboru v danem adresari 
        kratkaJmenaFtp = []
        for nazevSouboru in seznamFullPathSouboruNaFtpServeru:
            kratkaJmenaFtp.append(os.path.split(nazevSouboru)[-1])
        for localFile in os.listdir(localDirectory):
            fullPathLocalName = "%s%s" % (localDirectory , localFile)
            if os.path.isfile(fullPathLocalName) and (localFile in kratkaJmenaFtp) and (tarfile.is_tarfile(fullPathLocalName)):
                try:
                    self.ftp.delete(localFile)
                except ftplib.error_perm, ftplib.error_reply:
                    pass
                except Exception, why:
                    self.chyba += str(why)
                    raise
    
    def vLokalnimAdresariVymazSouborySeStejnymJmenem(self, remoteDirectory, localDirectory):
        '''
        prochazi vsechny soubory v remoteDirectory na ftp serveru a pokousi se vymazat 
        soubory se stejnym jmenem v localDirectory
        '''
        self.changeWorkingDirectoryOnFtpServer(remoteDirectory)
        seznamSouboru = self.opatrneNlst()
        for soubor in seznamSouboru:
            self.pokusSeVymazatLokalniSoubor(localDirectory, soubor)
            
            
    def pokusSeVymazatLokalniSoubor(self, localDirectory, soubor):
        fullFileName = os.path.join(localDirectory, soubor)
        if os.path.exists(fullFileName):
            try:
                os.remove(fullFileName)
            except Exception, why:
                gprsLogger.critical(why)                    
        
    def vymazObsahAdresare(self, directory):
        obsahAdresare = os.listdir(directory)
        for file in obsahAdresare:
            fullFileName = os.path.join(directory, file)            
            if os.path.isfile(fullFileName):
                os.remove(fullFileName)            
                
    def zjistiNejmladsiArchivZeZadanehoAdresare(self, directory):
        self.nazevNejmladsihoArchivuZeZadanehoAdresare = ''
        self.nazevNejmladsihoArchivu = ''
        files = [(os.stat(os.path.join(directory, file))[-2],file) for file in os.listdir(directory)]
        files.sort()
        files.reverse()
        soubory = [information[1] for information in files ]
        for soubor in soubory:                        
            try:
                pathFileName = os.path.join(directory, soubor)
#                print pathFileName
                if tarfile.is_tarfile(pathFileName):                    
                    self.nazevNejmladsihoArchivuZeZadanehoAdresare = soubor
                    soubor = soubor.split('.') #ziskame list se jmenem a priponami                    
                    self.nazevNejmladsihoArchivu = soubor[0] # pouze nazev souboru (bez pripadnych extenzi)
                    return
            except IOError: # kdyz to neni soubor, ale adresar
                pass

            
class KomprimaceTarBz2(object):
    def __init__(self):        
        self.chyba = "" 
        
    def komprimujSouboryDoTarBz2(self, fullSourceDirectoryPath, nazevTarBz2Souboru):
        '''
        !!!!! soubor, ktery je pridan do archivu je po pridani do archivu smazan !!!!!
        komprimuje soubory daneho adresare (ne podadresare, nebo soubory podadresaru!!!) 
        do tar.bz2 archivu, archiv vznikne v adresari fullSourceDirectoryPath (tj v adresari
        ve kterem jsou umisteny nekomprimovane soubory)
        '''        
        try:
            os.chdir(fullSourceDirectoryPath)
            tar = tarfile.open(fullSourceDirectoryPath+nazevTarBz2Souboru, "w:bz2")
            #for soubor in os.listdir(fullSourceDirectoryPath):
            #    print "DBG-file-k-prenosu:",soubor
            for soubor in os.listdir(fullSourceDirectoryPath):
                fullFileName = os.path.join(fullSourceDirectoryPath, soubor)
                # do archivu nepridavame adresare a existujici archivy
                #print "PD-DBG-file:",fullFileName
                if os.path.isfile(fullFileName) and (not fullFileName.endswith(".tar.bz2")):
                    tar.add(soubor)
                    # soubory, ktere pridame do archivu, smazeme
                    #print "PD-DBG-remove:",fullFileName
                    os.remove(fullFileName)
            tar.close()
            return True
        except Exception, why:        
            self.chyba += str(why)
            gprsLogger.critical(self.chyba)

    def komprimujSouboryDoTarBz2APresunuj(self, fullSourceDirectoryPath, nazevTarBz2Souboru, fullTargetDirectoryPath, presunSoubory = False):
        '''
        !!!!! soubor, ktery je pridan do archivu je po pridani do archivu presunut do target dir !!!!!
        komprimuje soubory daneho adresare (ne podadresare, nebo soubory podadresaru!!!) 
        do tar.bz2 archivu, archiv vznikne v adresari fullSourceDirectoryPath (tj v adresari
        ve kterem jsou umisteny nekomprimovane soubory)
        '''        
        try:
            os.chdir(fullSourceDirectoryPath)
            tar = tarfile.open(fullSourceDirectoryPath+nazevTarBz2Souboru, "w:bz2")
            #for soubor in os.listdir(fullSourceDirectoryPath):
            #    print "DBG-file-k-prenosu:",soubor
            for soubor in os.listdir(fullSourceDirectoryPath):
                fullFileName = os.path.join(fullSourceDirectoryPath, soubor)
                # do archivu nepridavame adresare a existujici archivy
                #print "PD-DBG-file:",fullFileName
                if os.path.isfile(fullFileName) and (not fullFileName.endswith(".tar.bz2")):
                    tar.add(soubor)
                    # soubory, ktere pridame do archivu, presuneme
#TODO:zda presunovat soubory do adresare pro prenos dat na nas vlastni server, kdyz soubory z tohoto adresare na nas server zatim neprenasime. adresar se zachvili zaplni a ...
                    if presunSoubory:
                        shutil.move(fullFileName,fullTargetDirectoryPath)
                    else:
                        # aby soubory nezustavaly v adresari pro dalsi prenos
                        os.remove(fullFileName)
            tar.close()
            return True
        except Exception, why:          
            self.chyba += str(why)
            gprsLogger.critical(self.chyba)

    def dekomprimujTarBz2Soubor(self, fullPath2TarBz2, nazevTarBz2Souboru, fullPathKamRozbalit=''):
        ''' rozbali obsah archivu tar.Bz2 do zadaneho adresare, 
            v pripade, ze cilovy adresar neexistuje, je tento adresar vytvoren
            v pripade, ze neni cilovy adresar zadan, je obsah rozbalen do adresare, 
            kde je umisten archiv tar.bz2 '''        
        if not fullPathKamRozbalit:
            fullPathKamRozbalit = fullPath2TarBz2
        try:        
            if tarfile.is_tarfile(fullPath2TarBz2 + nazevTarBz2Souboru):
    #            os.chdir(fullPath2TarBz2)
                tar = tarfile.open(fullPath2TarBz2 + nazevTarBz2Souboru)
                tar.extractall(fullPathKamRozbalit)
                tar.close()
            return True
        except Exception, why:        
            self.chyba += str(why)
            gprsLogger.critical(self.chyba)

    def exportujDataCSV(self, adresarPrenosDatProCentraluFTP, tabulka):        
        nazevTabulky = tabulka.sqlmeta.table
        print 'NAZEV TABULKY:', nazevTabulky
        predlohaNazvuSouboru = "%s%s%s" % (adresarPrenosDatProCentraluFTP, nazevTabulky, '_%s.csv')
        self.nazevSouboru = predlohaNazvuSouboru % time.strftime('%Y.%m.%d_%H%M%S')        
        '''
        z tabulek, ve kterych je pole priznakExportovano vybereme jen radky, ktere jeste exportovany nebyly,
        z tabulek, ktere pole priznakExportovano neobsahuji, vybereme vsechny zaznamy (radky)        
        '''
        try:
            if nazevTabulky == "udalosti_automatu":
                #print "Evidence udalosti - se tridenim ..."
                self.dataProCSV = tabulka.selectBy(priznakExportovano = False).orderBy("tStamp")
            else:
                self.dataProCSV = tabulka.selectBy(priznakExportovano = False)
            self._exportujCSV()
            if os.path.isfile(self.nazevSouboru): #v pripade, ze se podarilo vyexportovat CSV soubor, exportovane radky oznacime True
                for radek in self.dataProCSV:
                    radek.priznakExportovano = True 
                    
        except TypeError:
            self.dataProCSV = tabulka.select()       
            self._exportujCSV()

    def zjistiMtimeNejmladsihoArchivuZAdresare(self, directory):
    # vrati nulu, pokud nenajde zadny
        files = [(os.stat(os.path.join(directory, file))[-2],file) for file in os.listdir(directory)]
        files.sort(reverse=True)
        for soubor in files:
            pathFileName = os.path.join(directory, soubor[1])
            if os.path.isfile(pathFileName) and pathFileName.endswith(".tar.bz2"):
                return soubor[0]
        return 0
            
    def zjistiTimestampRadku(self, text):
    # vrati nulu, kdyz to nejde zjistit
        try:
            datumCas=text.split(" ",2)
            ts=time.mktime(time.strptime("%s %s" % (datumCas[0],datumCas[1]),"%d.%m.%Y %H:%M:%S"))
            return ts
        except Exception:
            # v podstate bud nejaky IndexError (nesplitlo se) nebo chyby od strptime ...
            return 0

    def kopirujLogCriticalAOkoli(self, inFile, outFile, timeLimit):
    # kopiruje radky -pocetRadkuPredCritical,+pocetRadkuPoCritical okolo intervalu vyskytu CRITICAL, pouze novejsi nez
    # timelimit - to se naplni volanim pro zjisteni nejmladsiho archivu ...
        intervaly=[]
        vIntervalu=False
        radek=0
        vstup=file(inFile,"r")
        while 1:
            textRadku=vstup.readline()
            if not textRadku: break
            radek=radek+1
            if self.zjistiTimestampRadku(textRadku)<timeLimit: continue
            if "CRITICAL" in textRadku:
                if not(vIntervalu):
                    minRadek=radek
                    maxRadek=radek
                    vIntervalu=True
                else: maxRadek=radek
            else:
                if vIntervalu:
                    minRadek=minRadek-pocetRadkuPredCritical
                    maxRadek=maxRadek+pocetRadkuPoCritical
                    intervaly.append((minRadek,maxRadek))
                    vIntervalu=False
        # zakonceni zahajeneho intervalu pri konci souboru
        if vIntervalu:
            minRadek=minRadek-pocetRadkuPredCritical
            maxRadek=maxRadek+pocetRadkuPoCritical
            intervaly.append((minRadek,maxRadek))
            vIntervalu=False
        # ted vystup souboru ... pokud je neco vybrano ! On totiz nasledne dale
        # pouzity is_tarfile soubory nulove delky rozpozna jako archivy a dela to
        # neporadek !
        if len(intervaly)==0:
            vstup.close()
            return
        vystup=file(outFile,"w")
        vstup.seek(0,0)
        radek=0
        while 1:
            textRadku=vstup.readline()
            if not textRadku: break
            radek=radek+1
            for interval in intervaly:
                if (radek>=interval[0]) and (radek<=interval[1]):
                    vystup.write(textRadku)
                    break;
        vystup.close()
        vstup.close()

    def pridejTakeLogovaciSoubory(self, adresarLog, destination):        
        limitDatumuLogu = self.zjistiMtimeNejmladsihoArchivuZAdresare(destination)
        for name in os.listdir(adresarLog):
            try:
                if os.path.isfile(adresarLog+name):
                    if os.path.splitext(name)[-1] in ('.log', ):
                        source = adresarLog + name
                        target = destination + name
                        self.kopirujLogCriticalAOkoli(source,target,limitDatumuLogu)
            except IOError:
                pass

    def pridejTakeVsechnyLogovaciSoubory(self, adresarLog, destination):        
        for name in os.listdir(adresarLog):
            try:
                if os.path.isfile(adresarLog+name):
                    if os.stat(adresarLog+name).st_size:
                        # kopirujeme soubory s nenulovou delkou
                        source = adresarLog + name
                        target = destination + name
                        shutil.copyfile(source, target)
            except IOError:
                pass

    def vymazLogy(self, adresarLog, souboryLog):
        for soubor in souboryLog:
            fileNameFull = adresarLog+soubor
            if os.path.exists(fileNameFull ):
                os.remove(fileNameFull ) # vymazeme logovaci soubory, ktere pripadne 

    def _exportujCSV(self):
        if len(list(self.dataProCSV)): # kdyz select na danou tabulku vratil nejaka data
            f = open(self.nazevSouboru, 'w')
            export_csv(self.dataProCSV, writer=f)
            f.close()

# vlastni prenosy - jako procedury
def prenesDataCentrala(provestExportDat=True,celeLogy=False):
    # slouzi pro prenos dat na nas vlastni servisni server 
    from tabulky import UdalostiAutomatu
    
    from nacteniKonfigurace import adresarPrenosDatProCentraluFTP, adresarDataProAutomat, absCestaRootNaServeruFTPCentrala
    from nacteniKonfigurace import adresarProUpdateSoubory
    from nacteniKonfigurace import souborLogGprs, nazevFTPserveruCentrala, ftpUserCentrala, ftpPasswCentrala
    from nacteniKonfigurace import adresarLog    

#    cisloAutomatu = CommandsAndStatus.get(1).idAutomatu
    cisloAutomatu = _zjistiCisloAutomatu()
    tabulkyProExportDat = []
                           
    exporter = KomprimaceTarBz2()    
    #=========================
    if provestExportDat:
        for tabulka in tabulkyProExportDat:        
            exporter.exportujDataCSV(adresarPrenosDatProCentraluFTP, tabulka)
        if celeLogy:
            exporter.pridejTakeVsechnyLogovaciSoubory(adresarLog, adresarPrenosDatProCentraluFTP)
            # Plny prenos prenese pro kontrolu i aktualni data.py soubor.
            #shutil.copy("/automat/data.py",adresarPrenosDatProCentraluFTP)
        else:
            exporter.pridejTakeLogovaciSoubory(adresarLog, adresarPrenosDatProCentraluFTP)
        exporter.vymazLogy(adresarLog, ("smsrestart.log", "servis.log"))
        nazevTarBz2Souboru = '%s%s_%d%s' % (cisloAutomatu, time.strftime('_%Y.%m.%d_%H%M%S'), zjistiPythonSwVerzi(), '.tar.bz2')
        exporter.komprimujSouboryDoTarBz2(adresarPrenosDatProCentraluFTP, nazevTarBz2Souboru)

    # Poznamenat zahajeni prenosu.
    f=file(razitkoPrenosZahajenCentrala,"w")
    f.close()
    # A tim padem zrusit signalizaci preneseni dat (uz to bude pripadne v rezii opakovani prenosu dat).
    if os.path.exists(semaforPrenesDataCentrala):
        os.remove(semaforPrenesDataCentrala)
    # A jdeme na to ...
    prenasec = GprsKomunikace()
    samiJsmeSiNahodiliGPRS = False
    
    
    if not prenasec.pidBezicihoGPRS:
        if not prenasec.startGPRS():
            text = "modulu pro prenos dat se nepodarilo aktivovat GPRS, prenos dat Centrala nebude proveden"
            print text
            gprsLogger.error(text)
            return
        else:
            text = "modul pro prenos dat si sam uspesne aktivoval GPRS"
            print text
            gprsLogger.info(text)
            samiJsmeSiNahodiliGPRS = True # kdyz neni detekovano bezici (jiz existujici) GPRS 
                                          # sami jej nahodime a nakonci jej zas budeme chtit vypnout
                                          # proto si musime zaznamenat, ze jsme si jej sami nahodili
    else:
        text = "modul pro prenos dat detekoval existujici spojeni GPRS/VPN"
        print text
        gprsLogger.error(text)
                                          
    #=========================
    text = "zahajuji prenos dat Centrala"
    print text
    gprsLogger.info(text)
    prenasec.zalogujSeNaFtpServer(nazevFTPserveruCentrala, ftpUserCentrala, ftpPasswCentrala, absCestaRootNaServeruFTPCentrala)
    prenasec.archivyDanehoAdresarePosliNaFtpServer(adresarPrenosDatProCentraluFTP, absCestaRootNaServeruFTPCentrala)
    prenasec.vLokalnimAdresariVymazSouborySeStejnymJmenem(absCestaRootNaServeruFTPCentrala, adresarPrenosDatProCentraluFTP)
    # stahneme soubory z adresare, ve kterem muze byt generalni update pro vsechny automaty
    cestaOdkudStahovat = "%s%s" % (absCestaRootNaServeruFTPCentrala, 'updateAll')
    prenasec.stahniZeServeruFtp(cestaOdkudStahovat, adresarDataProAutomat)
    
    cestaOdkudStahovat = "%s%s" % (absCestaRootNaServeruFTPCentrala, cisloAutomatu)    
    prenasec.stahniZeServeruFtp(cestaOdkudStahovat, adresarDataProAutomat)    
    prenasec.naFtpServeruVymazSouborySeStejnymJmenem(cestaOdkudStahovat, adresarDataProAutomat)    
    text = "data uspesne prenesena"
    print text
    gprsLogger.info(text)
    if samiJsmeSiNahodiliGPRS:
        prenasec.stopGPRS()    
    # v pripade, ze je v adresari dataProAutomat vice souboru, je vybran pouze ten nejmladsi
    prenasec.zjistiNejmladsiArchivZeZadanehoAdresare(adresarDataProAutomat)
    if prenasec.nazevNejmladsihoArchivu.startswith('updatujAutomat'):
        if exporter.dekomprimujTarBz2Soubor(adresarDataProAutomat, 
                                            prenasec.nazevNejmladsihoArchivuZeZadanehoAdresare, 
                                            adresarProUpdateSoubory):           
            #if os.path.exists(adresarProUpdateSoubory+'data.py'): # kdyz jsme prijali nove hodnoty pro databazi automatu
            #    shutil.move(adresarProUpdateSoubory+'data.py', '/automat/data.py.new')
            os.chdir(adresarProUpdateSoubory)
            if len(os.listdir(adresarProUpdateSoubory)): # kdyz jsou pritomny nejake soubory pro update
                f = open(pozadavekChciProvest, 'w') # vytvorime semaforovy soubor
                if prenasec.nazevNejmladsihoArchivu.startswith('updatujAutomatVcetneDbVzdalenyRestart'):
                    if os.path.exists(semaforPrihlasenTechnik):                        
                        f.write("updatujAutomatVcetneDbLokalniRestart")
                    else:
                        f.write('updatujAutomatVcetneDbVzdalenyRestart')
                elif prenasec.nazevNejmladsihoArchivu.startswith('updatujAutomatVzdalenyRestart'):                
                    if os.path.exists(semaforPrihlasenTechnik):                        
                        f.write("updatujAutomatLokalniRestart")
                    else:
                        f.write('updatujAutomatVzdalenyRestart')
                f.close()
    prenasec.vymazObsahAdresare(adresarDataProAutomat)
    if os.path.exists(razitkoPrenosZahajenCentrala):
        os.remove(razitkoPrenosZahajenCentrala)
    if os.path.exists(pocetOpakovaniPrenosuCentrala):
        os.remove(pocetOpakovaniPrenosuCentrala)
    
def prenesDataTelem(provestExportDat=True,celeLogy=False):
    # slouzi pro prenos dat na server zakaznika
    from tabulky import UdalostiAutomatu
    
    from nacteniKonfigurace import adresarDataTelemetrie, adresarPrenosDatProCentraluFTP, absCestaRootNaServeruFTPTelem
    from nacteniKonfigurace import nazevFTPserveruTelem, ftpUserTelem, ftpPasswTelem
    from nacteniKonfigurace import adresarLog    

#    cisloAutomatu = CommandsAndStatus.get(1).idAutomatu
    cisloAutomatu = _zjistiCisloAutomatu()
    tabulkyProExportDat = [UdalostiAutomatu]
                           
    exporter = KomprimaceTarBz2()    
    #=========================
    if provestExportDat:
        for tabulka in tabulkyProExportDat:        
            exporter.exportujDataCSV(adresarDataTelemetrie, tabulka)
        nazevTarBz2Souboru = '%s%s_%d%s' % (cisloAutomatu, time.strftime('_%Y.%m.%d_%H%M%S'), zjistiPythonSwVerzi(), '.tar.bz2')
        exporter.komprimujSouboryDoTarBz2APresunuj(adresarDataTelemetrie, nazevTarBz2Souboru, adresarPrenosDatProCentraluFTP)

    # Poznamenat zahajeni prenosu.
    f=file(razitkoPrenosZahajenTelem,"w")
    f.close()
    # A tim padem zrusit signalizaci preneseni dat (uz to bude pripadne v rezii opakovani prenosu dat).
    if os.path.exists(semaforPrenesDataTelem):
        os.remove(semaforPrenesDataTelem)
    # A jdeme na to ...
    prenasec = GprsKomunikace()
    samiJsmeSiNahodiliGPRS = False
    
    
    if not prenasec.pidBezicihoGPRS:
        if not prenasec.startGPRS():
            text = "modulu pro prenos dat se nepodarilo aktivovat GPRS, prenos dat Telemetrie nebude proveden"
            print text
            gprsLogger.error(text)
            return
        else:
            text = "modul pro prenos dat si sam uspesne aktivoval GPRS"
            print text
            gprsLogger.info(text)
            samiJsmeSiNahodiliGPRS = True # kdyz neni detekovano bezici (jiz existujici) GPRS 
                                          # sami jej nahodime a nakonci jej zas budeme chtit vypnout
                                          # proto si musime zaznamenat, ze jsme si jej sami nahodili
    else:
        text = "modul pro prenos dat detekoval existujici spojeni GPRS/VPN"
        print text
        gprsLogger.error(text)
                                          
    #=========================
    text = "zahajuji prenos dat Telemetrie"
    print text
    gprsLogger.info(text)
    prenasec.zalogujSeNaFtpServer(nazevFTPserveruTelem, ftpUserTelem, ftpPasswTelem, absCestaRootNaServeruFTPTelem)
    prenasec.archivyDanehoAdresarePosliNaFtpServer(adresarDataTelemetrie, absCestaRootNaServeruFTPTelem)
    prenasec.vLokalnimAdresariVymazSouborySeStejnymJmenem(absCestaRootNaServeruFTPTelem, adresarDataTelemetrie)

    text = "data uspesne prenesena"
    print text
    gprsLogger.info(text)
    if samiJsmeSiNahodiliGPRS:
        prenasec.stopGPRS()    

    if os.path.exists(razitkoPrenosZahajenTelem):
        os.remove(razitkoPrenosZahajenTelem)
    if os.path.exists(pocetOpakovaniPrenosuTelem):
        os.remove(pocetOpakovaniPrenosuTelem)

if __name__=='__main__':
    #prenesDataCentrala() # toto je prenos na nas vlastni server
    prenesDataTelem()
